{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6rOkSeCPRaYZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b07cdf1-e20a-4626-dadf-e6a89b4a7325"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import TensorDataset, DataLoader\n",
        "import matplotlib.pyplot as plt\n",
        "import time\n",
        "import copy\n",
        "from sklearn.metrics import mean_absolute_error\n",
        "from sklearn.metrics import r2_score"
      ],
      "metadata": {
        "id": "UCi3IeEnR0Pr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the device\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "print(device)\n",
        "\n",
        "training_data = np.load('/content/gdrive/My Drive/ALD/training_n_data.npy')\n",
        "training_std = np.load('/content/gdrive/My Drive/ALD/training_std.npy')\n",
        "\n",
        "testing_data = np.load('/content/gdrive/My Drive/ALD/testing_n_data.npy')\n",
        "testing_std = np.load('/content/gdrive/My Drive/ALD/testing_std.npy')\n",
        "\n",
        "# Reshape to 2D Array\n",
        "training_data = training_data.reshape(training_data.shape[0], 3, -1)\n",
        "testing_data = testing_data.reshape(testing_data.shape[0], 3, -1)\n",
        "\n",
        "# Convert to PyTorch tensors\n",
        "training_data_tensor = torch.tensor(training_data, dtype=torch.float32).to(device)\n",
        "training_std_tensor = torch.tensor(training_std, dtype=torch.float32).to(device)\n",
        "testing_data_tensor = torch.tensor(testing_data, dtype=torch.float32).to(device)\n",
        "testing_std_tensor = torch.tensor(testing_std, dtype=torch.float32).to(device)\n",
        "\n",
        "# Create TensorDatasets\n",
        "train_dataset = TensorDataset(training_data_tensor, training_std_tensor)\n",
        "test_dataset = TensorDataset(testing_data_tensor, testing_std_tensor)\n",
        "\n",
        "# Create DataLoaders\n",
        "train_loader = DataLoader(train_dataset, batch_size=20, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=50, shuffle=False)"
      ],
      "metadata": {
        "id": "6oj1Gx2DRlRb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "76ccac54-03b7-4c06-ce2c-72bcd39174b8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class CNN(nn.Module):\n",
        "    def __init__(self, input_size=40):\n",
        "        super().__init__()\n",
        "        self.conv1 = nn.Conv1d(3, 82, kernel_size=3, stride=1)\n",
        "        self.fc1 = nn.Linear(82 * (input_size - 2), 512)\n",
        "        self.fc2 = nn.Linear(512, 120)\n",
        "        self.fc3 = nn.Linear(120, 10)\n",
        "        self.fc4 = nn.Linear(10, 1)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = F.relu(self.conv1(x))\n",
        "        #x = self.pool(x)\n",
        "        x = x.view(x.size(0), -1)\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        x = F.relu(self.fc3(x))\n",
        "        x = self.fc4(x)\n",
        "        return x"
      ],
      "metadata": {
        "id": "v9z6aB_IRyky"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "criterion = nn.L1Loss()"
      ],
      "metadata": {
        "id": "v8C9S_XlR5oO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "num_features = next(iter(train_loader))[0].size(-1)\n",
        "[[i for i in range(0, num_features, n)] for n in range(2, 20)]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pnTQToeoBFxZ",
        "outputId": "823ef456-2265-41c5-b2fc-c06a3fcc95c9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38],\n",
              " [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39],\n",
              " [0, 4, 8, 12, 16, 20, 24, 28, 32, 36],\n",
              " [0, 5, 10, 15, 20, 25, 30, 35],\n",
              " [0, 6, 12, 18, 24, 30, 36],\n",
              " [0, 7, 14, 21, 28, 35],\n",
              " [0, 8, 16, 24, 32],\n",
              " [0, 9, 18, 27, 36],\n",
              " [0, 10, 20, 30],\n",
              " [0, 11, 22, 33],\n",
              " [0, 12, 24, 36],\n",
              " [0, 13, 26, 39],\n",
              " [0, 14, 28],\n",
              " [0, 15, 30],\n",
              " [0, 16, 32],\n",
              " [0, 17, 34],\n",
              " [0, 18, 36],\n",
              " [0, 19, 38]]"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def feature_selection(train_loader, test_loader, criterion, device, epochs=300):\n",
        "    results = []  # list to hold the results\n",
        "    num_features = next(iter(train_loader))[0].size(-1)\n",
        "\n",
        "    # Here are some different patterns of columns to keep\n",
        "    column_patterns = [\n",
        "        # The range function generates a sequence of numbers over time, and takes three arguments:\n",
        "        # 'start', 'stop', and 'step'.\n",
        "\n",
        "        list(range(0, num_features, n)) for n in range(2, 20) # For each n from 2 to 13, a list of column indices is generated.\n",
        "\n",
        "        # Here, we start at 0 and stop before 'num_features'. 'num_features' should be set to the total number of columns.\n",
        "        # 'step' defines the increment between each index in the list. We create different patterns by changing the step size.\n",
        "    ]\n",
        "\n",
        "    for pattern in column_patterns:\n",
        "        print(f\"Training with pattern {pattern}\")\n",
        "\n",
        "        model = CNN(len(pattern)).to(device)\n",
        "        optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)\n",
        "\n",
        "        for i in range(epochs):\n",
        "            train_loss = 0.0\n",
        "            test_loss = 0.0\n",
        "\n",
        "            model.train()\n",
        "            for b, (X_train, y_train) in enumerate(train_loader):\n",
        "                # Keep only columns in the pattern\n",
        "                X_train = X_train[:, :, pattern].to(device)\n",
        "                y_train = y_train.to(device)\n",
        "\n",
        "                y_pred = model(X_train)\n",
        "                target = y_train.view(-1, 1)\n",
        "                target = target.expand_as(y_pred)\n",
        "                loss = criterion(y_pred, target)\n",
        "\n",
        "                optimizer.zero_grad()\n",
        "                loss.backward()\n",
        "                optimizer.step()\n",
        "\n",
        "                train_loss += loss.item()\n",
        "\n",
        "            average_train_loss = train_loss / len(train_loader)\n",
        "\n",
        "            model.eval()\n",
        "            with torch.no_grad():\n",
        "                for X_test, y_test in test_loader:\n",
        "                    # Keep only columns in the pattern\n",
        "                    X_test = X_test[:, :, pattern].to(device)\n",
        "                    y_test = y_test.to(device)\n",
        "\n",
        "                    y_val = model(X_test)\n",
        "                    target = y_test.view(-1, 1)\n",
        "                    target = target.expand_as(y_val)\n",
        "                    loss = criterion(y_val, target)\n",
        "\n",
        "                    test_loss += loss.item()\n",
        "\n",
        "            average_test_loss = test_loss / len(test_loader)\n",
        "\n",
        "            if i % (epochs//2) == 0:\n",
        "                print(f'Epoch: {i}/{epochs} | Train Loss: {average_train_loss:.6f} | Test Loss: {average_test_loss:.6f}')\n",
        "\n",
        "        with torch.no_grad():\n",
        "          y_pred = model(testing_data_tensor[:, :, pattern])\n",
        "          y_pred_cpu = y_pred.cpu()\n",
        "\n",
        "          testing_std_tensor_cpu = testing_std_tensor.cpu()\n",
        "\n",
        "          mae = mean_absolute_error(testing_std_tensor_cpu, y_pred_cpu)\n",
        "          r_squared = r2_score(testing_std_tensor_cpu, y_pred_cpu)\n",
        "\n",
        "        results.append((pattern, average_train_loss, mae, r_squared))\n",
        "\n",
        "    return results\n"
      ],
      "metadata": {
        "id": "aNfFmzSfR7bf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "results = feature_selection(train_loader, test_loader, criterion, device, epochs=200)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tqExxmuJSDwc",
        "outputId": "16399c6e-8a25-4e16-9cab-f48f4859e9b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training with pattern [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38]\n",
            "Epoch: 0/200 | Train Loss: 0.011911 | Test Loss: 0.005962\n",
            "Epoch: 100/200 | Train Loss: 0.001566 | Test Loss: 0.002134\n",
            "Training with pattern [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39]\n",
            "Epoch: 0/200 | Train Loss: 0.014543 | Test Loss: 0.011126\n",
            "Epoch: 100/200 | Train Loss: 0.001826 | Test Loss: 0.001374\n",
            "Training with pattern [0, 4, 8, 12, 16, 20, 24, 28, 32, 36]\n",
            "Epoch: 0/200 | Train Loss: 0.013469 | Test Loss: 0.006713\n",
            "Epoch: 100/200 | Train Loss: 0.001088 | Test Loss: 0.001407\n",
            "Training with pattern [0, 5, 10, 15, 20, 25, 30, 35]\n",
            "Epoch: 0/200 | Train Loss: 0.018906 | Test Loss: 0.010376\n",
            "Epoch: 100/200 | Train Loss: 0.001912 | Test Loss: 0.001496\n",
            "Training with pattern [0, 6, 12, 18, 24, 30, 36]\n",
            "Epoch: 0/200 | Train Loss: 0.029667 | Test Loss: 0.010867\n",
            "Epoch: 100/200 | Train Loss: 0.001995 | Test Loss: 0.001399\n",
            "Training with pattern [0, 7, 14, 21, 28, 35]\n",
            "Epoch: 0/200 | Train Loss: 0.011755 | Test Loss: 0.007661\n",
            "Epoch: 100/200 | Train Loss: 0.001091 | Test Loss: 0.000803\n",
            "Training with pattern [0, 8, 16, 24, 32]\n",
            "Epoch: 0/200 | Train Loss: 0.028748 | Test Loss: 0.011806\n",
            "Epoch: 100/200 | Train Loss: 0.001739 | Test Loss: 0.001485\n",
            "Training with pattern [0, 9, 18, 27, 36]\n",
            "Epoch: 0/200 | Train Loss: 0.016744 | Test Loss: 0.010487\n",
            "Epoch: 100/200 | Train Loss: 0.001292 | Test Loss: 0.001810\n",
            "Training with pattern [0, 10, 20, 30]\n",
            "Epoch: 0/200 | Train Loss: 0.023336 | Test Loss: 0.014173\n",
            "Epoch: 100/200 | Train Loss: 0.001328 | Test Loss: 0.000927\n",
            "Training with pattern [0, 11, 22, 33]\n",
            "Epoch: 0/200 | Train Loss: 0.020157 | Test Loss: 0.011524\n",
            "Epoch: 100/200 | Train Loss: 0.001948 | Test Loss: 0.001340\n",
            "Training with pattern [0, 12, 24, 36]\n",
            "Epoch: 0/200 | Train Loss: 0.020749 | Test Loss: 0.010469\n",
            "Epoch: 100/200 | Train Loss: 0.002041 | Test Loss: 0.001634\n",
            "Training with pattern [0, 13, 26, 39]\n",
            "Epoch: 0/200 | Train Loss: 0.019804 | Test Loss: 0.012981\n",
            "Epoch: 100/200 | Train Loss: 0.002225 | Test Loss: 0.003031\n",
            "Training with pattern [0, 14, 28]\n",
            "Epoch: 0/200 | Train Loss: 0.028609 | Test Loss: 0.012285\n",
            "Epoch: 100/200 | Train Loss: 0.002199 | Test Loss: 0.002732\n",
            "Training with pattern [0, 15, 30]\n",
            "Epoch: 0/200 | Train Loss: 0.017886 | Test Loss: 0.011934\n",
            "Epoch: 100/200 | Train Loss: 0.001807 | Test Loss: 0.001738\n",
            "Training with pattern [0, 16, 32]\n",
            "Epoch: 0/200 | Train Loss: 0.017393 | Test Loss: 0.011459\n",
            "Epoch: 100/200 | Train Loss: 0.002062 | Test Loss: 0.001909\n",
            "Training with pattern [0, 17, 34]\n",
            "Epoch: 0/200 | Train Loss: 0.026135 | Test Loss: 0.012047\n",
            "Epoch: 100/200 | Train Loss: 0.002114 | Test Loss: 0.001760\n",
            "Training with pattern [0, 18, 36]\n",
            "Epoch: 0/200 | Train Loss: 0.021932 | Test Loss: 0.010876\n",
            "Epoch: 100/200 | Train Loss: 0.002033 | Test Loss: 0.002096\n",
            "Training with pattern [0, 19, 38]\n",
            "Epoch: 0/200 | Train Loss: 0.016400 | Test Loss: 0.010809\n",
            "Epoch: 100/200 | Train Loss: 0.001912 | Test Loss: 0.001900\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_results_MAE(results):\n",
        "    patterns = [str(r[0]) for r in results]\n",
        "    MAE = [r[2] for r in results]\n",
        "\n",
        "    fig, ax = plt.subplots(figsize=(10,4))\n",
        "    plt.xticks(fontsize=8)\n",
        "    plt.yticks(fontsize=20)\n",
        "\n",
        "    for i in range(len(patterns)):\n",
        "      print(f\"Patterns: {patterns[i]} | MAE: {MAE[i]}\")\n",
        "\n",
        "    ax.scatter(patterns, MAE)\n",
        "\n",
        "    for i, txt in enumerate(MAE):\n",
        "        if 0 <=  MAE[i] <= 0.02:\n",
        "            ax.text(i,  MAE[i], str(round(txt, 4)), fontsize=8)\n",
        "\n",
        "    ax.set_xlabel('Column Pattern')\n",
        "    ax.set_ylabel('MAE')\n",
        "    ax.set_ylim(0.0001, 0.004)\n",
        "    plt.xticks(rotation='vertical')\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "kx1BnrNmSDVS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_results_MAE(results)"
      ],
      "metadata": {
        "id": "_N5Zz91mnq6O",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "9bd83932-e1d9-4913-d2f2-b0f9d3b843ce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Patterns: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38] | MAE: 0.000778054993133992\n",
            "Patterns: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39] | MAE: 0.0010178671218454838\n",
            "Patterns: [0, 4, 8, 12, 16, 20, 24, 28, 32, 36] | MAE: 0.001545551116578281\n",
            "Patterns: [0, 5, 10, 15, 20, 25, 30, 35] | MAE: 0.0011192791862413287\n",
            "Patterns: [0, 6, 12, 18, 24, 30, 36] | MAE: 0.0009357602684758604\n",
            "Patterns: [0, 7, 14, 21, 28, 35] | MAE: 0.0006833277875557542\n",
            "Patterns: [0, 8, 16, 24, 32] | MAE: 0.001131455646827817\n",
            "Patterns: [0, 9, 18, 27, 36] | MAE: 0.0008969380869530141\n",
            "Patterns: [0, 10, 20, 30] | MAE: 0.0007056877366267145\n",
            "Patterns: [0, 11, 22, 33] | MAE: 0.0007971988525241613\n",
            "Patterns: [0, 12, 24, 36] | MAE: 0.001200433704070747\n",
            "Patterns: [0, 13, 26, 39] | MAE: 0.001624998520128429\n",
            "Patterns: [0, 14, 28] | MAE: 0.0014445151900872588\n",
            "Patterns: [0, 15, 30] | MAE: 0.0011325104860588908\n",
            "Patterns: [0, 16, 32] | MAE: 0.001665559713728726\n",
            "Patterns: [0, 17, 34] | MAE: 0.001242280239239335\n",
            "Patterns: [0, 18, 36] | MAE: 0.0013939884956926107\n",
            "Patterns: [0, 19, 38] | MAE: 0.0015180996851995587\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_results_r2(results):\n",
        "    patterns = [str(r[0]) for r in results]\n",
        "    r2 = [r[3] for r in results]\n",
        "    fig, ax = plt.subplots(figsize=(10,4))\n",
        "    plt.xticks(fontsize=8)\n",
        "    plt.yticks(fontsize=20)\n",
        "\n",
        "    for i in range(len(patterns)):\n",
        "      print(f\"Patterns: {patterns[i]} | R-Squared: {r2[i]}\")\n",
        "\n",
        "    ax.scatter(patterns, r2)\n",
        "    for i, txt in enumerate(r2):\n",
        "        if 0 <= r2[i] <= 1:\n",
        "            ax.text(i, r2[i], str(round(txt, 4)), fontsize=8)\n",
        "\n",
        "\n",
        "    ax.set_xlabel('Column Pattern')\n",
        "    ax.set_ylabel('R-Squared')\n",
        "    ax.set_ylim(.975, 1)\n",
        "    plt.xticks(rotation='vertical')\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "uO20hqSIm560"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_results_r2(results)"
      ],
      "metadata": {
        "id": "kzrkGrvaaDS1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "34b5d6ef-22e8-4734-cd2e-9ec182f1fd27"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Patterns: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38] | R-Squared: 0.9990718546128553\n",
            "Patterns: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39] | R-Squared: 0.9968700730447874\n",
            "Patterns: [0, 4, 8, 12, 16, 20, 24, 28, 32, 36] | R-Squared: 0.9972952554974305\n",
            "Patterns: [0, 5, 10, 15, 20, 25, 30, 35] | R-Squared: 0.9975274089004302\n",
            "Patterns: [0, 6, 12, 18, 24, 30, 36] | R-Squared: 0.998429555027575\n",
            "Patterns: [0, 7, 14, 21, 28, 35] | R-Squared: 0.9992233646927501\n",
            "Patterns: [0, 8, 16, 24, 32] | R-Squared: 0.9972983462758326\n",
            "Patterns: [0, 9, 18, 27, 36] | R-Squared: 0.9985569835789869\n",
            "Patterns: [0, 10, 20, 30] | R-Squared: 0.9991529801259912\n",
            "Patterns: [0, 11, 22, 33] | R-Squared: 0.9987235708916207\n",
            "Patterns: [0, 12, 24, 36] | R-Squared: 0.9965757911225968\n",
            "Patterns: [0, 13, 26, 39] | R-Squared: 0.990968846317936\n",
            "Patterns: [0, 14, 28] | R-Squared: 0.9924017255432654\n",
            "Patterns: [0, 15, 30] | R-Squared: 0.9965247475724248\n",
            "Patterns: [0, 16, 32] | R-Squared: 0.9947585235640274\n",
            "Patterns: [0, 17, 34] | R-Squared: 0.9951977209287015\n",
            "Patterns: [0, 18, 36] | R-Squared: 0.9942341274833085\n",
            "Patterns: [0, 19, 38] | R-Squared: 0.9952298063605961\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Okoh5bcfpKPG"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}